/** 
    ____                            
   / __ )_________ __   _____  _____
  / __  / ___/ __ `/ | / / _ \/ ___/
 / /_/ / /  / /_/ /| |/ /  __/ /    
/_____/_/   \__,_/ |___/\___/_/     
* @Title: AsyncThreadCacheLoader.java 
* @Package soft.ay.qram.async 
* @Description: 异步操作
* @author vsuns 
* @date 2019年6月6日 
* @version V1.0 
*/ 
package soft.ay.qram.async;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import soft.ay.qram.ICacheLoader;
import soft.ay.qram.helpers.CacheLoaderContext;
import soft.ay.qram.helpers.ThreadPools;

/**  
*  
*/
public class AsyncThreadCacheLoader implements ICacheLoader
{
    // 需要用到的class
    Class<?> loaderClass = null;

    // classLoader
    ICacheLoader cacheLoader = null;

    public AsyncThreadCacheLoader(Class<?> loaderClass)
    {
        super();
        this.loaderClass = loaderClass;
        cacheLoader = CacheLoaderContext.createLoader(loaderClass);
    }



    // 属性部分

    //------------------分割线------------------
    // 方法部分

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @param value
     * 
     * @see soft.ay.qram.ICacheLoader#addToCache(java.lang.String,
     * java.lang.String)
     */

    @Override
    public void addToCache(String key, String value)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        Runnable subTask = new Runnable()
        {

            @Override
            public void run()
            {
                // 注意：使用控制语句时，将头尾位置用注释标记起来
                // 局部变量定义的地方

                // 逻辑处理开始的地方
                cacheLoader.addToCache(key, value);
                // 逻辑处理结束的地方

                // 局部变量销毁的地方
            }
        };
        ThreadPools.newFixedThreadPool.execute(subTask);

        // 逻辑处理结束的地方

        // 局部变量销毁的地方
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @param value
     * 
     * @param unit
     * 
     * @param expire
     * 
     * @see soft.ay.qram.ICacheLoader#addToCache(java.lang.String,
     * java.lang.String, java.util.concurrent.TimeUnit, java.lang.Long)
     */

    @Override
    public void addToCache(String key, String value, TimeUnit unit, Long expire)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        Runnable subTask = new Runnable()
        {

            @Override
            public void run()
            {
                // 注意：使用控制语句时，将头尾位置用注释标记起来
                // 局部变量定义的地方

                // 逻辑处理开始的地方
                cacheLoader.addToCache(key, value, unit, expire);
                // 逻辑处理结束的地方

                // 局部变量销毁的地方
            }
        };
        ThreadPools.newFixedThreadPool.execute(subTask);

        // 逻辑处理结束的地方

        // 局部变量销毁的地方
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @return
     * 
     * @see soft.ay.qram.ICacheLoader#getFromCache(java.lang.String)
     */

    @Override
    public String getFromCache(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        try
        {
            CompletableFuture<String> thenApply = CompletableFuture.completedFuture("getbykey").thenApply(s -> {
                return cacheLoader.getFromCache(key);
            });
            return thenApply.get();
        }
        catch (InterruptedException | ExecutionException e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
        return null;
    }

    /*
     * (非 Javadoc) *
     * 
     * @return
     * 
     * @see soft.ay.qram.ICacheLoader#getKeys()
     */

    @Override
    public Set<String> getKeys()
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        try
        {
            CompletableFuture<Set<String>> thenApply = CompletableFuture.completedFuture("getbykey").thenApply(s -> {
                return cacheLoader.getKeys();
            });
            return thenApply.get();
        }
        catch (InterruptedException | ExecutionException e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
        return null;
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @return
     * 
     * @see soft.ay.qram.ICacheLoader#containKey(java.lang.String)
     */

    @Override
    public Boolean containKey(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方

        try
        {
            CompletableFuture<Boolean> thenApply = CompletableFuture.completedFuture("getbykey").thenApply(s -> {
                return cacheLoader.containKey(key);
            });
            return thenApply.get();
        }
        catch (InterruptedException | ExecutionException e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
        return null;
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @see soft.ay.qram.ICacheLoader#removeKey(java.lang.String)
     */

    @Override
    public void removeKey(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        Runnable subTask = new Runnable()
        {

            @Override
            public void run()
            {
                // 注意：使用控制语句时，将头尾位置用注释标记起来
                // 局部变量定义的地方

                // 逻辑处理开始的地方
                cacheLoader.removeKey(key);
                // 逻辑处理结束的地方

                // 局部变量销毁的地方
            }
        };
        ThreadPools.newFixedThreadPool.execute(subTask);

        // 逻辑处理结束的地方

        // 局部变量销毁的地方
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @param unit
     * 
     * @param expire
     * 
     * @see soft.ay.qram.ICacheLoader#expireKey(java.lang.String,
     * java.util.concurrent.TimeUnit, java.lang.Long)
     */

    @Override
    public void expireKey(String key, TimeUnit unit, Long expire)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        Runnable subTask = new Runnable()
        {

            @Override
            public void run()
            {
                // 注意：使用控制语句时，将头尾位置用注释标记起来
                // 局部变量定义的地方

                // 逻辑处理开始的地方
                cacheLoader.expireKey(key, unit, expire);
                // 逻辑处理结束的地方

                // 局部变量销毁的地方
            }
        };
        ThreadPools.newFixedThreadPool.execute(subTask);
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @see soft.ay.qram.ICacheLoader#persistKey(java.lang.String)
     */

    @Override
    public void persistKey(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        Runnable subTask = new Runnable()
        {

            @Override
            public void run()
            {
                // 注意：使用控制语句时，将头尾位置用注释标记起来
                // 局部变量定义的地方

                // 逻辑处理开始的地方
                cacheLoader.persistKey(key);
                // 逻辑处理结束的地方

                // 局部变量销毁的地方
            }
        };
        ThreadPools.newFixedThreadPool.execute(subTask);
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @return
     * 
     * @see soft.ay.qram.ICacheLoader#matchKey(java.lang.String)
     */

    @Override
    public Set<String> matchKey(String key)
    {
        // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        try
        {
            CompletableFuture<Set<String>> thenApply = CompletableFuture.completedFuture("matchkey").thenApply(s -> {
                return cacheLoader.matchKey(key);
            });
            return thenApply.get();
        }
        catch (InterruptedException | ExecutionException e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
        return null;
    }

    /*
     * (非 Javadoc) *
     * 
     * @param key
     * 
     * @return
     * 
     * @see soft.ay.qram.ICacheLoader#getFromCacheByMatchKey(java.lang.String)
     */

    @Override
    public Map<String, String> getFromCacheByMatchKey(String key)
    {
     // 注意：使用控制语句时，将头尾位置用注释标记起来
        // 局部变量定义的地方

        // 逻辑处理开始的地方
        try
        {
            CompletableFuture<Map<String, String>> thenApply = CompletableFuture.completedFuture("getByMatchkey").thenApply(s -> {
                                                                                    return cacheLoader.getFromCacheByMatchKey(key);
            });
            return thenApply.get();
        }
        catch (InterruptedException | ExecutionException e)
        {
            e.printStackTrace();
        }
        // 逻辑处理结束的地方

        // 局部变量销毁的地方
        return null;
    }

}
